Mitigating ROP attacks

ABSTRACT

Mitigating return-oriented programming attacks. Program code and associated components are received and loaded into memory. From the program code and associated components, a predetermined number of sequences of machine language instructions that terminate in a return instruction are selected. The sequences of machine language instructions include: machine language instruction sequences that are equivalent to a conditional statement “if-then-else return,” sequences of machine language instructions corresponding to known malicious code sequences, and sequences of machine language instructions corresponding to machine language instructions in known toolkits for assembling malicious code sequences. For each selected machine language instruction sequence, memory blocks containing the selected machine language instruction sequence are rearranged using address space layout randomization (ASLR); then, upon expiration of an expected time interval required to locate the selected machine language instruction sequence by inspecting the rearranged memory blocks, the rearranging is repeated, thereby mitigating ROP attacks.

BACKGROUND

The present invention relates generally to the field of informationsecurity, and more particularly to prevention of return-orientedprogramming (ROP) attacks.

ROP is a powerful technique by which an attacker can induce unwantedbehavior in a computer program whose control the attacker has diverted,without injecting any malicious code. As such, ROP may be used toovercome various strategies designed to prevent the execution ofmalicious code in the data area, such as data execution prevention(DEP), a security feature in modern operating systems that marks certainareas of memory as non-executable and others as executable. DEP allowsonly data in an area marked as executable to be run by programs,services, device drivers, etc.

When using ROP, an attacker uses control over the execution stack priorto a function return to direct code execution to some other location inthe program. It is relatively straightforward to achieve almostarbitrary code execution by compiling a payload, or malicious codesequence, consisting of a combination of carefully chosen machinelanguage instruction sequences, called gadgets. Gadgets are generallyshort, typically two to five instructions long, end in a returninstruction, and are located in a subroutine within program code orshared library code, for example, libc, the C standard library, or inWindows dlls. A gadget may, for example, consist of a single machinelanguage instruction followed by a return. Various automated tools havebeen developed to aid in locating gadgets to use in an ROP exploitation.

Address space layout randomization (ASLR) is a computer securitytechnique involved in protection from buffer overflow attacks. In orderto prevent an attacker from reliably jumping to, for example, aparticular exploited function in memory, ASLR randomly rearranges theaddress space positions of key data areas of a process, including thebase of the executable and the positions of the stack, heap, andlibraries. ASLR is designed to prevent attacks that make assumptionsabout the load address of code, but ROP attacks may circumvent ASLR byscanning memory and either finding a known anchor in the code area andcalculating offsets from it, or searching for gadgets in the scannedmemory.

Another approach to ROP mitigation is instruction location randomization(ILR). ILR focuses on preventing attacks which rely on code beinglocated predictably by randomizing the location of every instruction ina program. Each instruction has an explicit successor, but thisinformation is hidden from an attacker, thus preventing an attacker fromeasily locating the gadgets required to create a particular maliciouscode sequence. However, ILR may reduce the stability of runningprocesses and/or severely degrade the end-user experience.

SUMMARY

Embodiments of the present invention disclose a computer-implementedmethod, computer program product, and system for mitigatingreturn-oriented programming (ROP) attacks. Program code and associatedcomponents needed by the program code for execution are received andloaded into memory. From the program code and associated components, apredetermined number of sequences of machine language instructions thatterminate in a return instruction are selected. The sequences of machinelanguage instructions include: machine language instruction sequencesthat are equivalent to a conditional statement “if-then-else return,”sequences of machine language instructions corresponding to knownmalicious code sequences, and sequences of machine language instructionscorresponding to machine language instructions in known toolkits forassembling malicious code sequences. For each selected machine languageinstruction sequence, memory blocks containing the selected machinelanguage instruction sequence are rearranged using address space layoutrandomization (ASLR); then, upon expiration of an expected time intervalrequired to locate the selected machine language instruction sequence byinspecting the rearranged memory blocks, the rearranging is repeated,thereby mitigating ROP attacks.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 depicts a functional block diagram of a return-orientedprogramming (ROP) mitigation system, in accordance with an embodiment ofthe present invention.

FIG. 2 is a flowchart depicting operational steps of an ROP mitigationtool, in accordance with an embodiment of the present invention.

FIG. 3 is another flowchart depicting operational steps of an ROPmitigation tool, in accordance with an embodiment of the presentinvention.

FIG. 4 is another flowchart depicting operational steps of an ROPmitigation tool, in accordance with an embodiment of the presentinvention.

FIG. 5 is a functional block diagram illustrating a data processingenvironment, in accordance with an embodiment of the present invention.

DETAILED DESCRIPTION

Embodiments of the present invention disclose a computer-implementedmethod, computer program product, and system for mitigatingreturn-oriented programming (ROP) attacks. A set of gadgets isidentified in program code and shared libraries. The gadgets are clonedand the clones are marked non-executable. The gadgets and the clones arehidden by distributing them randomly in memory. If an attacker searchingfor gadgets to combine in an ROP exploit executes a non-executablegadget, an alert may be raised and protective action may be taken.

FIG. 1 is a functional block diagram of an ROP mitigation system 100, inaccordance with an embodiment of the present invention. ROP mitigationsystem 100 includes computing device 110. Computing device 110represents the computing environment or platform that hosts ROPmitigation tool 112. In various embodiments, computing device 110 may bea laptop computer, netbook computer, personal computer (PC), a desktopcomputer, or any programmable electronic device capable of hosting ROPmitigation tool 112, in accordance with embodiments of the invention.Computing device 110 may include internal and external hardwarecomponents, as depicted and described in further detail below withreference to FIG. 3.

In an exemplary embodiment of the invention, computing device 110includes ROP mitigation tool 112 and gadget datastore 120. ROPmitigation tool 112 may further include gadget selection module 114,gadget hiding module 116, and exploit reporting module 118.

Gadget datastore 120 represents a store of gadgets that may be clonedand stored in memory prior to a program execution, in accordance with anembodiment of the present invention. Gadget datastore 120 may reside,for example, on computer readable storage media 908 (FIG. 3).

ROP mitigation tool 112, in an exemplary embodiment of the invention,operates generally to clone a predetermined, configurable number of codegadgets prior to a process run start. ROP mitigation tool 112 may employdata execution prevention (DEP) to mark all pages containing theduplicated copies as non-executable, such that there are multiplenon-executable clones and only one executable copy. When an attackersearches the memory address space for gadgets to use in an ROP attack,the attacker encounters multiple copies of each gadget sought. The useof any of these gadgets, except the ones embedded in the executablecopy, will, due to DEP, raise an alert or cause the process to crash,allowing the attack to be reported and preventing the successfulconclusion of the attack. In various embodiments, ROP mitigation tool112 may be part of the system loader or may be some other privileged OStool. In other embodiments, ROP mitigation tool 112 may be included aspart of an anti-malware package.

Gadget selection module 114, in an embodiment of the invention, mayidentify gadgets to clone, for example, by searching program code and/orshared libraries in memory for machine code equivalent to a conditionalstatement “if-then-else . . . return” and extracting the code in theelse clause, including the return instruction. Alternatively, gadgetselection module may use knowledge of known examples of ROP attacks, orof known toolkits for assembling malicious code for an ROP attack, toselect the gadgets to clone.

In various embodiments of the present invention, gadget selection module114 may assemble a set of gadgets to clone from program code and sharedlibraries subsequent to these components being loaded into memory.Alternatively, or additionally, gadget selection module 114 may assemblea set of gadgets to clone prior to loading a program. Gadget selectionmodule 114 may store the gadgets to be cloned, or references to thegadgets, in gadget datastore 120.

Gadget hiding module 116, in response to a request for preventativeaction against a possible ROP attack, may make a predefined number ofcopies of gadgets in gadget datastore 120, in an exemplary embodiment ofthe invention. Gadget hiding module 116 may use DEP to mark blocks ofmemory, such as memory pages, procedures, or shared libraries,containing cloned gadgets, as non-executable. Gadget hiding module 116may employ for this purpose DEP, for example, hardware-enforced DEP, ifsupported by the operating system on computing device 110.Alternatively, gadget hiding module 116 may employ software-enforcedDEP, which emulates hardware-enforced DEP. Gadget hiding module 116 mayfurther use a technique such as address space layout randomization(ASLR) to rearrange memory blocks containing a gadget and memory blockscontaining non-executable clones of the gadget.

Exploit reporting module 118, in an exemplary embodiment of theinvention, may intercept alerts or exceptions raised as a result of anattacker attempting to execute a non-executable cloned gadget, andreport a potential ROP attack to the OS, which may initiate protectiveor ameliorative measures. For example, the OS may terminate one or moreactive processes and report a possible exploit.

In an alternative embodiment of the invention, a gadget is identified bygadget selection module 114 in loaded program code or shared librarycode. Gadget hiding module 116 may “hide” the gadget by using ASLR torandomly permute a number of memory blocks containing the gadget, basedon the size of the code in which the gadget is located.

In various embodiments of the present invention, ROP mitigation viagadget cloning and/or hiding may be viewed as a two-person, zero-sumgame, the solution of which is well known in game theory. The firstplayer, or defender, tries to make it difficult to find real, orexecutable, gadgets by selecting an appropriate number of gadgets toclone, and deciding where to hide them, for example, in a systemlibrary. The second player, or attacker, searches for gadgets and checksif they are real or not. The cost to the defender includes the number ofgadgets the defender can clone without severely impacting memoryconsumption. The cost to the attacker is associated with searching for apredetermined number of real gadgets. The solution of this two-personzero-sum game, known as a Nash equilibrium, may lead to a cloning/hidingapproach that yields an optimal defense against an ROP attack.

For example, suppose that, in an embodiment of the invention, anattacker searches for a specific gadget, which gadget hiding module 116,the defender, has hidden among a number of randomly permuted blocks ofmemory, as described above. Applying an optimal strategy, the attackerchooses a random order, or permutation, to search the memory blocks. Interms of game theory, the cost of the search, which the attacker pays tothe defender, is the number of blocks that must be checked beforefinding the gadget. For example, suppose there are four memory blocks,b₁, b₂, b₃b₄, one of which, b₃, contains the gadget. If the attackerrandomly chooses to search the blocks in the order 4, 2, 3, 1, then thecost to the attacker in searching for this particular gadget is 3. Ingeneral, suppose that N is a collection of n memory blocks, one of whichcontains a gadget sought by an attacker. An optimal strategy for thedefender is to randomly select one of these to contain the gadget. Asmentioned, an optimal strategy for the attacker is to randomly choose,with probability 1/(n!), one of the n! possible orders to inspect the nblocks. Since there are (n−1) ! orders in which a gadget is hidden in aparticular block of the n blocks, the expected, or average, cost to theattacker in searching for the hidden gadget is

${\frac{1}{n!}{\left( {n - 1} \right)!}\left( {1 + 2 + \ldots + n} \right)} = \frac{n + 1}{2}$That is, the attacker will have to search, on average, (n+1)/2 memoryblocks in order to find the gadget. This represents a Nash equilibriumbecause there is no gain if either of the players adopts a differentstrategy. Based on this result, it would be advantageous for a defenderre-hide the real gadget before an attacker has an opportunity to search(n+1)/2 blocks. The determination of when to re-hide a gadget may bebased on monitoring processes' reading of memory blocks, or on anestimate of the time it would take for a process to read (n+1)/2 blocks.

An equivalent result holds if, instead of hiding a gadget among n memoryblocks, a defender hides a gadget among n copies of a gadget, of whichonly one is executable and all others are non-executable clones.

It may be shown, using game theoretical reasoning as above, that hidinga real gadget and at least one non-executable clone of the gadget amongn blocks of memory is a more effective strategy than just hiding asingle gadget among n blocks of memory. That is, the expected cost to anattacker is greater if the attacker may first encounter either the realgadget or a non-executable clone in inspecting memory blocks in a randomorder.

In another embodiment, gadget hiding module 116 chooses from gadgetdatastore 120 a number k of individual, executable gadgets, which may beassembled in a particular order to generate a payload, and stores themin memory in random order. Only if an attacker accesses the gadgets inmemory in the correct order does the attack succeed. Game theory may beapplied here as well. In this case, the n blocks described above mayrepresent the k! different orders, in which an attacker might inspectthe k gadgets. Choosing the correct order is equivalent to choosing thesame element of N as the defender, as above.

Exploit reporting module 118, in an exemplary embodiment of theinvention, may intercept alerts or exceptions raised as a result of anattacker attempting to execute a non-executable cloned gadget, andreport a potential ROP attack to the operating system for possiblefurther preventative or ameliorative measures. Alternatively, exploitreporting module 118 may report that a set of gadgets that may becombined to create a payload, and which have been permuted in memory,have been accessed in the wrong order.

FIG. 2 is a flowchart depicting operational steps performed by computingdevice 110 in executing ROP mitigation tool 112, in accordance with anexemplary embodiment of the invention. Gadget selection module 114identifies gadgets in loaded program code and/or shared libraries andstores them in gadget datastore 120 (step 210). For each gadget, gadgethiding module 116 makes a predefined number of non-executable clones(step 212), stores the gadget and the clones in memory (step 214), andrandomly permutes the memory blocks containing the gadget and the clones(step 216). In response to a process attempting to execute anon-executable clone, exploit reporting module 118 reports a possibleROP exploit to the operating system for protective action (step 218).

FIG. 3 is a flowchart depicting operational steps performed by computingdevice 110 in executing ROP mitigation tool 112, in an alternativeembodiment of the invention. Gadget selection module 114 identifiesgadgets in loaded program code and/or shared libraries and stores themin gadget datastore 120 (step 310). For each gadget, gadget hidingmodule 116 estimates the expected time T it would take for an attackerto find the gadget by inspecting randomly permuted memory blockscontaining the gadget (step 312). Gadget hiding module 116 randomlypermutes memory blocks containing the gadget (step 314). So long as timeT has not expired (decision step 318, NO branch), program executioncontinues (step 316). At expiration of time T (decision step 318, YESbranch), the memory blocks containing the gadget are again randomlypermuted (step 314).

FIG. 4 is a flowchart depicting operational steps performed by computingdevice 110 in executing ROP mitigation tool 112, in another embodimentof the invention. Gadget selection module 114 identifies gadgets inloaded program code and/or shared libraries and stores them in gadgetdatastore 120 (step 410). Gadget selection module 114 selects a set ofgadgets from gadget datastore 120 that may be combined in a certainorder to create a payload (step 412). Gadget hiding module 116 randomlypermutes the selected gadgets in memory (step 414). In response to thegadgets being accessed in the wrong order, exploit reporting module 118reports a possible ROP exploit to the operating system for protectiveaction (step 416).

FIG. 5 depicts a block diagram of components of a computing device 110,in accordance with an embodiment of the present invention. It should beappreciated that FIG. 5 provides only an illustration of oneimplementation and does not imply any limitations with regard to theenvironments in which different embodiments may be implemented. Manymodifications to the depicted environment may be made.

Computing device 110 may include one or more processors 902, one or morecomputer-readable RAMs 904, one or more computer-readable ROMs 906, oneor more computer readable storage media 908, device drivers 912,read/write drive or interface 914, network adapter or interface 916, allinterconnected over a communications fabric 918. Communications fabric918 may be implemented with any architecture designed for passing dataand/or control information between processors (such as microprocessors,communications and network processors, etc.), system memory, peripheraldevices, and any other hardware components within a system.

One or more operating systems 910, and one or more application programs928, for example, ROP mitigation tool 112, are stored on one or more ofthe computer readable storage media 908 for execution by one or more ofthe processors 902 via one or more of the respective RAMs 904 (whichtypically include cache memory). In the illustrated embodiment, each ofthe computer readable storage media 908 may be a magnetic disk storagedevice of an internal hard drive, CD-ROM, DVD, memory stick, magnetictape, magnetic disk, optical disk, a semiconductor storage device suchas RAM, ROM, EPROM, flash memory or any other computer-readable tangiblestorage device that can store a computer program and digitalinformation.

Computing device 110 may also include a R/W drive or interface 914 toread from and write to one or more portable computer readable storagemedia 926. Application programs 928 on computing device 110 may bestored on one or more of the portable computer readable storage media926, read via the respective R/W drive or interface 914 and loaded intothe respective computer readable storage media 908.

Computing device 110 may also include a network adapter or interface916, such as a TCP/IP adapter card or wireless communication adapter(such as a 4G wireless communication adapter using OFDMA technology).Application programs 928 on computing device 110 may be downloaded tothe computing device from an external computer or external storagedevice via a network (for example, the Internet, a local area network orother wide area network or wireless network) and network adapter orinterface 916. From the network adapter or interface 916, the programsmay be loaded onto computer readable storage media 908. The network maycomprise copper wires, optical fibers, wireless transmission, routers,firewalls, switches, gateway computers and/or edge servers.

Computing device 110 may also include a display screen 920, a keyboardor keypad 922, and a computer mouse or touchpad 924. Device drivers 912interface to display screen 920 for imaging, to keyboard or keypad 922,to computer mouse or touchpad 924, and/or to display screen 920 forpressure sensing of alphanumeric character entry and user selections.The device drivers 912, R/W drive or interface 914 and network adapteror interface 916 may comprise hardware and software (stored on computerreadable storage media 908 and/or ROM 906).

The present invention may be a system, a method, and/or a computerprogram product. The computer program product may include a computerreadable storage medium (or media) having computer readable programinstructions thereon for causing a processor to carry out aspects of thepresent invention.

The computer readable storage medium can be a tangible device that canretain and store instructions for use by an instruction executiondevice. The computer readable storage medium may be, for example, but isnot limited to, an electronic storage device, a magnetic storage device,an optical storage device, an electromagnetic storage device, asemiconductor storage device, or any suitable combination of theforegoing. A non-exhaustive list of more specific examples of thecomputer readable storage medium includes the following: a portablecomputer diskette, a hard disk, a random access memory (RAM), aread-only memory (ROM), an erasable programmable read-only memory (EPROMor Flash memory), a static random access memory (SRAM), a portablecompact disc read-only memory (CD-ROM), a digital versatile disk (DVD),a memory stick, a floppy disk, a mechanically encoded device such aspunch-cards or raised structures in a groove having instructionsrecorded thereon, and any suitable combination of the foregoing. Acomputer readable storage medium, as used herein, is not to be construedas being transitory signals per se, such as radio waves or other freelypropagating electromagnetic waves, electromagnetic waves propagatingthrough a waveguide or other transmission media (e.g., light pulsespassing through a fiber-optic cable), or electrical signals transmittedthrough a wire.

Computer readable program instructions described herein can bedownloaded to respective computing/processing devices from a computerreadable storage medium or to an external computer or external storagedevice via a network, for example, the Internet, a local area network, awide area network and/or a wireless network. The network may comprisecopper transmission cables, optical transmission fibers, wirelesstransmission, routers, firewalls, switches, gateway computers and/oredge servers. A network adapter card or network interface in eachcomputing/processing device receives computer readable programinstructions from the network and forwards the computer readable programinstructions for storage in a computer readable storage medium withinthe respective computing/processing device.

Computer readable program instructions for carrying out operations ofthe present invention may be assembler instructions,instruction-set-architecture (ISA) instructions, machine instructions,machine dependent instructions, microcode, firmware instructions,state-setting data, or either source code or object code written in anycombination of one or more programming languages, including an objectoriented programming language such as Smalltalk, C++ or the like, andconventional procedural programming languages, such as the “C”programming language or similar programming languages. The computerreadable program instructions may execute entirely on the user'scomputer, partly on the user's computer, as a stand-alone softwarepackage, partly on the user's computer and partly on a remote computeror entirely on the remote computer or server. In the latter scenario,the remote computer may be connected to the user's computer through anytype of network, including a local area network (LAN) or a wide areanetwork (WAN), or the connection may be made to an external computer(for example, through the Internet using an Internet Service Provider).In some embodiments, electronic circuitry including, for example,programmable logic circuitry, field-programmable gate arrays (FPGA), orprogrammable logic arrays (PLA) may execute the computer readableprogram instructions by utilizing state information of the computerreadable program instructions to personalize the electronic circuitry,in order to perform aspects of the present invention.

Aspects of the present invention are described herein with reference toflowchart illustrations and/or block diagrams of methods, apparatus(systems), and computer program products according to embodiments of theinvention. It will be understood that each block of the flowchartillustrations and/or block diagrams, and combinations of blocks in theflowchart illustrations and/or block diagrams, can be implemented bycomputer readable program instructions.

These computer readable program instructions may be provided to aprocessor of a general purpose computer, special purpose computer, orother programmable data processing apparatus to produce a machine, suchthat the instructions, which execute via the processor of the computeror other programmable data processing apparatus, create means forimplementing the functions/acts specified in the flowchart and/or blockdiagram block or blocks. These computer readable program instructionsmay also be stored in a computer readable storage medium that can directa computer, a programmable data processing apparatus, and/or otherdevices to function in a particular manner, such that the computerreadable storage medium having instructions stored therein comprises anarticle of manufacture including instructions which implement aspects ofthe function/act specified in the flowchart and/or block diagram blockor blocks.

The computer readable program instructions may also be loaded onto acomputer, other programmable data processing apparatus, or other deviceto cause a series of operational steps to be performed on the computer,other programmable apparatus or other device to produce a computerimplemented process, such that the instructions which execute on thecomputer, other programmable apparatus, or other device implement thefunctions/acts specified in the flowchart and/or block diagram block orblocks.

The flowchart and block diagrams in the figures illustrate thearchitecture, functionality, and operation of possible implementationsof systems, methods, and computer program products according to variousembodiments of the present invention. In this regard, each block in theflowchart or block diagrams may represent a module, segment, or portionof instructions, which comprises one or more executable instructions forimplementing the specified logical function(s). In some alternativeimplementations, the functions noted in the block may occur out of theorder noted in the figures. For example, two blocks shown in successionmay, in fact, be executed substantially concurrently, or the blocks maysometimes be executed in the reverse order, depending upon thefunctionality involved. It will also be noted that each block of theblock diagrams and/or flowchart illustration, and combinations of blocksin the block diagrams and/or flowchart illustration, can be implementedby special purpose hardware-based systems that perform the specifiedfunctions or acts or carry out combinations of special purpose hardwareand computer instructions.

The programs described herein are identified based upon the applicationfor which they are implemented in a specific embodiment of theinvention. However, it should be appreciated that any particular programnomenclature herein is used merely for convenience, and thus theinvention should not be limited to use solely in any specificapplication identified and/or implied by such nomenclature.

The foregoing description of various embodiments of the presentinvention has been presented for purposes of illustration anddescription. It is not intended to be exhaustive nor to limit theinvention to the precise form disclosed. Many modifications andvariations are possible. Such modification and variations that may beapparent to a person skilled in the art of the invention are intended tobe included within the scope of the invention as defined by theaccompanying claims.

What is claimed is:
 1. A computer system for mitigating return-orientedprogramming (ROP) attacks, the computer system comprising: one or morecomputer processors, one or more non-transitory computer-readablestorage media, and program instructions stored on one or more of thenon-transitory computer-readable storage media for execution by at leastone of the one or more processors, the program instructions comprising:program instructions to receive program code for execution andassociated components needed by the program code for execution; programinstructions to load the program code and associated components intomemory; program instructions to select a predetermined number ofsequences of machine language instructions from the loaded program codeand the associated components, wherein each sequence terminates in areturn instruction, and wherein the predetermined number of sequencesincludes: machine language instruction sequences that are equivalent toa conditional statement “if-then-else return”; sequences of machinelanguage instructions corresponding to known malicious code sequences;and sequences of machine language instructions corresponding to machinelanguage instructions in known toolkits for assembling malicious codesequences; and for each selected machine language instruction sequence,program instructions to: rearrange memory blocks containing the selectedmachine language instruction sequence, using address space layoutrandomization (ASLR); then wait an expected time interval required tolocate the selected machine language instruction sequence by inspectingthe rearranged memory blocks; and repeat the rearranging at theexpiration of the expected time interval; whereby ROP attacks aremitigated.